home *** CD-ROM | disk | FTP | other *** search
/ Die Speccy' 97 / Die Speccy' 97.iso / amiga_system / the_aminet / comm / bbs / wwbbs31_source.lha / WWBBS / Handler / aux.c < prev    next >
C/C++ Source or Header  |  1995-06-20  |  16KB  |  561 lines
  1. #include <exec/types.h>
  2. #include <exec/exec.h>
  3. #include <dos/dos.h>
  4. #include <dos/dosextens.h>
  5. #include <dos/filehandler.h>
  6. #include <devices/timer.h>
  7. #include <libraries/wwbbs.h>
  8. #include <ctype.h>
  9. #include <stdio.h>
  10. #include <string.h>
  11.  
  12. #include <proto/exec.h>
  13. #include <proto/dos.h>
  14. #include <proto/wwbbs.h>
  15.  
  16. #include "wwbbsaux-handler_rev.h"
  17.  
  18. struct ExecBase *SysBase;
  19. struct DosLibrary *DOSBase;
  20. struct Library *WorldWideBase;
  21.  
  22. char *version=VERSTAG;
  23.  
  24. void __saveds wwbbs_aux(void);
  25. LONG __saveds input(BYTE *,BOOL,BYTE *,LONG,ULONG);
  26. BOOL __saveds print_local(BYTE *,BYTE *,ULONG);
  27. BOOL __saveds print_remote(BYTE *,BYTE *,ULONG);
  28. BOOL __saveds check_panic(BYTE *,BOOL);
  29. BOOL __saveds check_page(BYTE *,BOOL);
  30.  
  31. void __saveds wwbbs_aux()
  32.     {
  33.         struct Process *proc;
  34.         struct DosPacket *dp;
  35.         struct DeviceNode *dn;
  36.  
  37.         char id[33];
  38.         BOOL local=FALSE;
  39.  
  40.         ULONG opencount=0;
  41.         BOOL raw=FALSE,kg=TRUE;
  42.  
  43.         SysBase=(struct ExecBase *) 4;
  44.         DOSBase=(struct DosLibrary *) OpenLibrary("dos.library",0);
  45.         WorldWideBase=OpenLibrary("wwbbs.library",0);
  46.  
  47.         proc=(struct Process *) FindTask(NULL);
  48.         dp=WaitPkt();
  49.         dn=(struct DeviceNode *) BADDR(dp->dp_Arg3);
  50.         dp->dp_Arg4=(LONG) &proc->pr_MsgPort;
  51.         {
  52.             char buff[64],*p;
  53.             p=BADDR(dp->dp_Arg1);
  54.             sprintf(buff,"%.*s",(*p>63) ? 63 : *p,&p[1]);
  55.             strcpy(id,"");
  56.             if(p=strchr(buff,':'))
  57.                 {
  58.                     p++;
  59.                     sprintf(id,"%.32s",p);
  60.                 }
  61.         }
  62.         ReplyPkt(dp,DOSTRUE,0);
  63.  
  64.         GetStatusTags(STTAG_Name,id,STTAG_Local,&local,TAG_END);
  65.  
  66.         while(kg)
  67.             {
  68.                 dp=WaitPkt();
  69.                 switch(dp->dp_Type)
  70.                     {
  71.                         case ACTION_FINDUPDATE:
  72.                         case ACTION_FINDINPUT:
  73.                         case ACTION_FINDOUTPUT:
  74.                             opencount++;
  75.                             {
  76.                                 struct FileHandle *fh;
  77.                                 fh=(struct FileHandle *) BADDR(dp->dp_Arg1);
  78.                                 fh->fh_Port=(struct MsgPort *) DOSTRUE;
  79.                             }
  80.                             ReplyPkt(dp,DOSTRUE,NULL);
  81.                             break;
  82.                         case ACTION_END:
  83.                             opencount--;
  84.                             if(!opencount)
  85.                                 kg=FALSE;
  86.                             ReplyPkt(dp,DOSTRUE,NULL);
  87.                             break;
  88.                         case ACTION_READ:
  89.                             {
  90.                                 BYTE *buffer=NULL;
  91.                                 LONG num=0;
  92.                                 LONG ret=0;
  93.                                 buffer=(BYTE *) dp->dp_Arg2;
  94.                                 num=dp->dp_Arg3;
  95.                                 if(buffer && num)
  96.                                     {
  97.                                         UWORD inactivitytimelimit=0;
  98.                                         GetStatusTags(STTAG_Name,id,STTAG_InactivityTimeLimit,&inactivitytimelimit,TAG_END);
  99.                                         if(!check_panic(id,local))
  100.                                             {
  101.                                                 if(raw)
  102.                                                     {
  103.                                                         BYTE stack[256];
  104.                                                         strcpy(stack,"");
  105.                                                         GetStatusTags(STTAG_Name,id,STTAG_Stack,stack,TAG_END);
  106.                                                         if(strlen(stack))
  107.                                                             {
  108.                                                                 if(strlen(stack)>num)
  109.                                                                     {
  110.                                                                         strncpy(buffer,stack,num);
  111.                                                                         {
  112.                                                                             char buff[256];
  113.                                                                             strcpy(buff,&stack[num]);
  114.                                                                             strcpy(stack,buff);
  115.                                                                         }
  116.                                                                         ret=num;
  117.                                                                     }
  118.                                                                 else
  119.                                                                     {
  120.                                                                         strncpy(buffer,stack,strlen(stack));
  121.                                                                         ret=strlen(stack);
  122.                                                                         strcpy(stack,"");
  123.                                                                     }
  124.                                                                 SetStatusTags(STTAG_Name,id,STTAG_Stack,stack,TAG_END);
  125.                                                             }
  126.                                                         else
  127.                                                             {
  128.                                                                 check_page(id,local);
  129.                                                                 while(1)
  130.                                                                     {
  131.                                                                         if(ret=input(id,local,buffer,num,inactivitytimelimit*60*1000000))
  132.                                                                             break;
  133.                                                                         else
  134.                                                                             {
  135.                                                                                 if(!check_page(id,local))
  136.                                                                                     break;
  137.                                                                             }
  138.                                                                     }
  139.                                                             }
  140.                                                     }
  141.                                                 else
  142.                                                     {
  143.                                                         BOOL con_kg=TRUE,skip=FALSE;
  144.                                                         BYTE stack[256];
  145.                                                         strcpy(stack,"");
  146.                                                         GetStatusTags(STTAG_Name,id,STTAG_Stack,stack,TAG_END);
  147.                                                         while(con_kg && ret<num)
  148.                                                             {
  149.                                                                 skip=FALSE;
  150.                                                                 buffer[ret]=NULL;
  151.                                                                 if(strlen(stack))
  152.                                                                     {
  153.                                                                         buffer[ret]=stack[0];
  154.                                                                         {
  155.                                                                             char buff[256];
  156.                                                                             strcpy(buff,&stack[1]);
  157.                                                                             strcpy(stack,buff);
  158.                                                                         }
  159.                                                                     }
  160.                                                                 else
  161.                                                                     {
  162.                                                                         check_page(id,local);
  163.                                                                         if(!input(id,local,&buffer[ret],1,inactivitytimelimit*60*1000000))
  164.                                                                             {
  165.                                                                                 if(!check_page(id,local))
  166.                                                                                     {
  167.                                                                                         ret=0;
  168.                                                                                         break;
  169.                                                                                     }
  170.                                                                                 else
  171.                                                                                     skip=TRUE;
  172.                                                                             }
  173.                                                                     }
  174.                                                                 if(!skip && buffer[ret])
  175.                                                                     {
  176.                                                                         switch(buffer[ret])
  177.                                                                             {
  178.                                                                                 case '\b':
  179.                                                                                     if(ret)
  180.                                                                                         {
  181.                                                                                             ret--;
  182.                                                                                             if(local)
  183.                                                                                                 print_local(id,"\b \b",-1);
  184.                                                                                             else
  185.                                                                                                 print_remote(id,"\b \b",-1);
  186.                                                                                         }
  187.                                                                                     break;
  188.                                                                                 case '\r':
  189.                                                                                     buffer[ret]='\n';
  190.                                                                                     if(local)
  191.                                                                                         print_local(id,"\r\n",-1);
  192.                                                                                     else
  193.                                                                                         print_remote(id,"\r\n",-1);
  194.                                                                                     ret++;
  195.                                                                                     con_kg=FALSE;
  196.                                                                                     break;
  197.                                                                                 default:
  198.                                                                                     if(isprint(buffer[ret]))
  199.                                                                                         {
  200.                                                                                             if(local)
  201.                                                                                                 print_local(id,&buffer[ret],1);
  202.                                                                                             else
  203.                                                                                                 print_remote(id,&buffer[ret],1);
  204.                                                                                             ret++;
  205.                                                                                         }
  206.                                                                                     break;
  207.                                                                             }
  208.                                                                     }
  209.                                                             }
  210.                                                         SetStatusTags(STTAG_Name,id,STTAG_Stack,stack,TAG_END);
  211.                                                     }
  212.                                                 if(check_panic(id,local))
  213.                                                     ret=0;
  214.                                             }
  215.                                         if(!ret)
  216.                                             Signal(dp->dp_Port->mp_SigTask,SIGBREAKF_CTRL_C);
  217.                                     }
  218.                                 ReplyPkt(dp,ret,0);
  219.                             }
  220.                             break;
  221.                         case ACTION_WRITE:
  222.                             {
  223.                                 BYTE *buffer=NULL;
  224.                                 LONG num=0;
  225.                                 LONG ret=0;
  226.                                 buffer=(BYTE *) dp->dp_Arg2;
  227.                                 num=dp->dp_Arg3;
  228.                                 if(buffer && num)
  229.                                     {
  230.                                         if(!check_panic(id,local))
  231.                                             {
  232.                                                 BYTE *s;
  233.                                                 if(s=AllocVec(sizeof(BYTE)*(num+2),MEMF_CLEAR))
  234.                                                     {
  235.                                                         if(buffer[num-1]=='\n')
  236.                                                             sprintf(s,"%.*s\r\n",num-1,buffer);
  237.                                                         else
  238.                                                             sprintf(s,"%.*s",num,buffer);
  239.                                                         {
  240.                                                             BYTE *p,*q;
  241.                                                             p=q=s;
  242.                                                             while(*p)
  243.                                                                 {
  244.                                                                     if(q=strchr(p,'~'))
  245.                                                                         {
  246.                                                                             if(local)
  247.                                                                                 print_local(id,p,q-p);
  248.                                                                             else
  249.                                                                                 print_remote(id,p,q-p);
  250.                                                                             p=q;
  251.                                                                             p++;
  252.                                                                             if(*p)
  253.                                                                                 {
  254.                                                                                     BOOL ansi=FALSE;
  255.                                                                                     GetStatusTags(STTAG_Name,id,STTAG_ANSI,&ansi,TAG_END);
  256.                                                                                     if(ansi)
  257.                                                                                         {
  258.                                                                                             BYTE color[161],color_buff[81];
  259.                                                                                             strcpy(color,"");
  260.                                                                                             strcpy(color_buff,"");
  261.                                                                                             switch(*p)
  262.                                                                                                 {
  263.                                                                                                     case 'H':
  264.                                                                                                     case 'h':
  265.                                                                                                         GetConfigTags(CFGTAG_Name,"System",SYSTAG_HeaderColor,color_buff,TAG_END);
  266.                                                                                                         break;
  267.                                                                                                     case 'I':
  268.                                                                                                     case 'i':
  269.                                                                                                         GetConfigTags(CFGTAG_Name,"System",SYSTAG_InputColor,color_buff,TAG_END);
  270.                                                                                                         break;
  271.                                                                                                     case 'O':
  272.                                                                                                     case 'o':
  273.                                                                                                         GetConfigTags(CFGTAG_Name,"System",SYSTAG_OutputColor,color_buff,TAG_END);
  274.                                                                                                         break;
  275.                                                                                                     case 'P':
  276.                                                                                                     case 'p':
  277.                                                                                                         GetConfigTags(CFGTAG_Name,"System",SYSTAG_PromptColor,color_buff,TAG_END);
  278.                                                                                                         break;
  279.                                                                                                     case 'R':
  280.                                                                                                     case 'r':
  281.                                                                                                         strcpy(color_buff,"\\e[0m");
  282.                                                                                                         break;
  283.                                                                                                     case 'S':
  284.                                                                                                     case 's':
  285.                                                                                                         GetConfigTags(CFGTAG_Name,"System",SYSTAG_SystemColor,color_buff,TAG_END);
  286.                                                                                                         break;
  287.                                                                                                 }
  288.                                                                                             if(strlen(color_buff))
  289.                                                                                                 {
  290.                                                                                                     char *r;
  291.                                                                                                     int format=FALSE;
  292.                                                                                                     strcpy(color,"");
  293.                                                                                                     r=color_buff;
  294.                                                                                                     while(*r)
  295.                                                                                                         {
  296.                                                                                                             if(format)
  297.                                                                                                                 {
  298.                                                                                                                     switch(*r)
  299.                                                                                                                         {
  300.                                                                                                                             case 'e':
  301.                                                                                                                                 strcat(color,"\033");
  302.                                                                                                                                 break;
  303.                                                                                                                             case 't':
  304.                                                                                                                                 strcat(color,"\t");
  305.                                                                                                                                 break;
  306.                                                                                                                             case 'b':
  307.                                                                                                                                 strcat(color,"\b");
  308.                                                                                                                                 break;
  309.                                                                                                                             case 'n':
  310.                                                                                                                                 strcat(color,"\r\n");
  311.                                                                                                                                 break;
  312.                                                                                                                             case 'f':
  313.                                                                                                                                 strcat(color,"\f");
  314.                                                                                                                                 break;
  315.                                                                                                                         }
  316.                                                                                                                     format=FALSE;
  317.                                                                                                                 }
  318.                                                                                                             else
  319.                                                                                                                 {
  320.                                                                                                                     switch(*r)
  321.                                                                                                                         {
  322.                                                                                                                             case '\\':
  323.                                                                                                                                 format=TRUE;
  324.                                                                                                                                 break;
  325.                                                                                                                             default:
  326.                                                                                                                                 strncat(color,r,1);
  327.                                                                                                                                 break;
  328.                                                                                                                         }
  329.                                                                                                                 }
  330.                                                                                                             r++;
  331.                                                                                                         }
  332.                                                                                                     if(local)
  333.                                                                                                         print_local(id,color,strlen(color));
  334.                                                                                                     else
  335.                                                                                                         print_remote(id,color,strlen(color));
  336.                                                                                                 }
  337.                                                                                         }
  338.                                                                                     p++;
  339.                                                                                 }
  340.                                                                         }
  341.                                                                     else
  342.                                                                         {
  343.                                                                             if(local)
  344.                                                                                 print_local(id,p,strlen(p));
  345.                                                                             else
  346.                                                                                 print_remote(id,p,strlen(p));
  347.                                                                             break;
  348.                                                                         }
  349.                                                                 }
  350.                                                         }
  351.                                                         FreeVec(s);
  352.                                                     }
  353.                                                 ret=num;
  354.                                             }
  355.                                         else
  356.                                             Signal(dp->dp_Port->mp_SigTask,SIGBREAKF_CTRL_C);
  357.                                     }
  358.                                 if(ret==num)
  359.                                     ReplyPkt(dp,num,0);
  360.                                 else
  361.                                     ReplyPkt(dp,-1,ERROR_ACTION_NOT_KNOWN);
  362.                             }
  363.                             break;
  364.                         case ACTION_WAIT_CHAR:
  365.                             {
  366.                                 ULONG timeout=0;
  367.                                 LONG ret=DOSFALSE;
  368.                                 timeout=(ULONG) dp->dp_Arg1;
  369.                                 {
  370.                                     if(!check_panic(id,local))
  371.                                         {
  372.                                             BYTE stack[256];
  373.                                             strcpy(stack,"");
  374.                                             GetStatusTags(STTAG_Name,id,STTAG_Stack,stack,TAG_END);
  375.                                             if(timeout)
  376.                                                 {
  377.                                                     if(strlen(stack))
  378.                                                         ret=DOSTRUE;
  379.                                                     else
  380.                                                         {
  381.                                                             BYTE c;
  382.                                                             if(input(id,local,&c,1,timeout))
  383.                                                                 {
  384.                                                                     sprintf(stack,"%c",c);
  385.                                                                     SetStatusTags(STTAG_Name,id,STTAG_Stack,stack,TAG_END);
  386.                                                                     ret=DOSTRUE;
  387.                                                                 }
  388.                                                             else
  389.                                                                 {
  390.                                                                     if(check_panic(id,local))
  391.                                                                         Signal(dp->dp_Port->mp_SigTask,SIGBREAKF_CTRL_C);
  392.                                                                 }
  393.                                                         }
  394.                                                 }
  395.                                             else
  396.                                                 {
  397.                                                     if(strlen(stack))
  398.                                                         ret=DOSTRUE;
  399.                                                     else
  400.                                                         {
  401.                                                             if(local)
  402.                                                                 {
  403.                                                                     if(ConsoleCommandTags(id,CONCMD_Query,TAG_END))
  404.                                                                         ret=DOSTRUE;
  405.                                                                 }
  406.                                                             else
  407.                                                                 {
  408.                                                                     if(SerialCommandTags(id,SERCMD_Query,TAG_END))
  409.                                                                         ret=DOSTRUE;
  410.                                                                 }
  411.                                                         }
  412.                                                 }
  413.                                         }
  414.                                     else
  415.                                         Signal(dp->dp_Port->mp_SigTask,SIGBREAKF_CTRL_C);
  416.                                 }
  417.                                 ReplyPkt(dp,ret,(ret) ? NULL : ERROR_ACTION_NOT_KNOWN);
  418.                             }
  419.                             break;
  420.                         case ACTION_SCREEN_MODE:
  421.                             {
  422.                                 LONG mode=0;
  423.                                 mode=(LONG) dp->dp_Arg1;
  424.                                 raw=(mode) ? TRUE : FALSE;
  425.                                 ReplyPkt(dp,DOSTRUE,0);
  426.                             }
  427.                             break;
  428.                         default:
  429.                             ReplyPkt(dp,DOSFALSE,ERROR_ACTION_NOT_KNOWN);
  430.                             if(!opencount)
  431.                                 kg=FALSE;
  432.                             break;
  433.                     }
  434.             }
  435.  
  436.         CloseLibrary(WorldWideBase);
  437.         CloseLibrary((struct Library *) DOSBase);
  438.     }
  439.  
  440. LONG __saveds input(BYTE *id,BOOL local,BYTE *buffer,LONG num,ULONG timeout)
  441.     {
  442.         LONG ret=0;
  443.         struct MsgPort *TimerMP;
  444.         struct timerequest *TimerIO;
  445.         if(TimerMP=CreateMsgPort())
  446.             {
  447.                 if(TimerIO=(struct timerequest *) CreateIORequest(TimerMP,sizeof(struct timerequest)))
  448.                     {
  449.                         if(!OpenDevice(TIMERNAME,UNIT_VBLANK,(struct IORequest *) TimerIO,0))
  450.                             {
  451.                                 ULONG mask=NULL;
  452.                                 if(timeout)
  453.                                     {
  454.                                         TimerIO->tr_node.io_Command=TR_ADDREQUEST;
  455.                                         TimerIO->tr_time.tv_secs=timeout/1000000;
  456.                                         TimerIO->tr_time.tv_micro=timeout%1000000;
  457.                                         SendIO((struct IORequest *) TimerIO);
  458.                                         mask|=1 << TimerMP->mp_SigBit;
  459.                                     }
  460.                                 if(local)
  461.                                     {
  462.                                         ULONG c;
  463.                                         if(c=ConsoleCommandTags(id,CONCMD_Wait,CONWAITTAG_WaitMask,mask,TAG_END))
  464.                                             {
  465.                                                 buffer[0]=c;
  466.                                                 ret=1;
  467.                                                 while( (ret<num) && (c=ConsoleCommandTags(id,CONCMD_Read,TAG_END)) )
  468.                                                     {
  469.                                                         buffer[ret]=c;
  470.                                                         ret++;
  471.                                                     }
  472.                                             }
  473.                                     }
  474.                                 else
  475.                                     ret=SerialCommandTags(id,SERCMD_Wait,SERWAITTAG_Buffer,buffer,SERWAITTAG_Size,num,SERWAITTAG_WaitMask,mask,TAG_END);
  476.                                 if(!CheckIO((struct IORequest *) TimerIO))
  477.                                     {
  478.                                         AbortIO((struct IORequest *) TimerIO);
  479.                                         WaitIO((struct IORequest *) TimerIO);
  480.                                     }
  481.                                 CloseDevice((struct IORequest *) TimerIO);
  482.                             }
  483.                         DeleteIORequest(TimerIO);
  484.                     }
  485.                 DeleteMsgPort(TimerMP);
  486.             }
  487.         return(ret);
  488.     }
  489.  
  490. BOOL __saveds print_local(BYTE *id,BYTE *buffer,ULONG size)
  491.     {
  492.         BOOL ret=FALSE;
  493.         if(ConsoleCommandTags(id,CONCMD_Write,CONWRITETAG_Buffer,buffer,CONWRITETAG_Size,size,TAG_END))
  494.             ret=TRUE;
  495.         return(ret);
  496.     }
  497.  
  498. BOOL __saveds print_remote(BYTE *id,BYTE *buffer,ULONG size)
  499.     {
  500.         BOOL ret=FALSE;
  501.         ConsoleCommandTags(id,CONCMD_Write,CONWRITETAG_Buffer,buffer,CONWRITETAG_Size,size,TAG_END);
  502.         if(SerialCommandTags(id,SERCMD_Write,SERWRITETAG_Buffer,buffer,SERWRITETAG_Size,size,TAG_END))
  503.             ret=TRUE;
  504.         return(ret);
  505.     }
  506.  
  507. BOOL __saveds check_panic(BYTE *id,BOOL local)
  508.     {
  509.         BOOL ret=FALSE;
  510.         BOOL panic=FALSE;
  511.         GetStatusTags(STTAG_Name,id,STTAG_Panic,&panic,TAG_END);
  512.         if(panic)
  513.             ret=TRUE;
  514.         else
  515.             {
  516.                 if(!local)
  517.                     {
  518.                         if(!SerialCommandTags(id,SERCMD_Carrier,TAG_END))
  519.                             {
  520.                                 SetStatusTags(STTAG_Name,id,STTAG_Panic,TRUE,TAG_END);
  521.                                 ret=TRUE;
  522.                             }
  523.                     }
  524.             }
  525.         return(ret);
  526.     }
  527.  
  528. BOOL __saveds check_page(BYTE *id,BOOL local)
  529.     {
  530.         BOOL pagereceived=FALSE;
  531.         GetStatusTags(STTAG_Name,id,STTAG_PageReceived,&pagereceived,TAG_END);
  532.         if(pagereceived)
  533.             {
  534.                 {
  535.                     BPTR fh;
  536.                     BYTE filename[64],s[128];
  537.                     sprintf(filename,"T:wwbbs_page.%s",id);
  538.                     if(fh=Open(filename,MODE_OLDFILE))
  539.                         {
  540.                             if(local)
  541.                                 print_local(id,"\n",1);
  542.                             else
  543.                                 print_remote(id,"\n",1);
  544.                             while(FGets(fh,s,126))
  545.                                 {
  546.                                     s[strlen(s)-1]=NULL;
  547.                                     strcat(s,"\r\n");
  548.                                     if(local)
  549.                                         print_local(id,s,strlen(s));
  550.                                     else
  551.                                         print_remote(id,s,strlen(s));
  552.                                 }
  553.                             Close(fh);
  554.                             DeleteFile(filename);
  555.                             SetStatusTags(STTAG_Name,id,STTAG_PageReceived,FALSE,TAG_END);
  556.                         }
  557.                 }
  558.             }
  559.         return(pagereceived);
  560.     }
  561.